const fs = require('fs');
const path = require('path');

/**
 * 检查 msg.htm 文件的 body 标签是否为空
 * @param {string} msgFilePath - msg.htm 文件的完整路径
 * @returns {boolean} - 如果 body 标签为空返回 true，否则返回 false
 */
function isBodyEmpty(msgFilePath) {
    try {
        if (!fs.existsSync(msgFilePath)) {
            console.log(`文件不存在: ${msgFilePath}`);
            return false;
        }

        const htmlContent = fs.readFileSync(msgFilePath, 'utf-8');
        
        // 使用正则表达式提取 body 标签内容
        const bodyMatch = htmlContent.match(/<body[^>]*>(.*?)<\/body>/is);
        
        if (!bodyMatch) {
            console.log(`未找到 body 标签: ${msgFilePath}`);
            return false;
        }

        // 获取 body 标签内的内容
        const bodyContent = bodyMatch[1];
        
        // 移除 HTML 标签，只保留文本内容
        const textContent = bodyContent.replace(/<[^>]*>/g, '').trim();
        
        const isEmpty = textContent === '';
        
        console.log(`检查文件: ${msgFilePath}, body 内容为空: ${isEmpty}`);
        return isEmpty;
    } catch (error) {
        console.error(`检查文件时出错 ${msgFilePath}:`, error.message);
        return false;
    }
}

/**
 * 递归删除目录
 * @param {string} dirPath - 要删除的目录路径
 */
function removeDirectory(dirPath) {
    try {
        if (fs.existsSync(dirPath)) {
            fs.rmSync(dirPath, { recursive: true, force: true });
            console.log(`已删除目录: ${dirPath}`);
            return true;
        }
    } catch (error) {
        console.error(`删除目录时出错 ${dirPath}:`, error.message);
        return false;
    }
}

/**
 * 检查并删除无效的子目录
 * @param {string} parentDir - 父目录路径
 */
function cleanEmptySubDirs(parentDir) {
    try {
        if (!fs.existsSync(parentDir)) {
            console.log(`父目录不存在: ${parentDir}`);
            return;
        }

        const items = fs.readdirSync(parentDir);
        let deletedCount = 0;
        let totalDirs = 0;

        for (const item of items) {
            const itemPath = path.join(parentDir, item);
            const stat = fs.statSync(itemPath);

            // 只处理目录，跳过文件
            if (stat.isDirectory()) {
                totalDirs++;
                const msgFilePath = path.join(itemPath, 'msg.htm');
                
                // 检查是否存在 msg.htm 文件且 body 标签为空
                if (fs.existsSync(msgFilePath) && isBodyEmpty(msgFilePath)) {
                    console.log(`发现无效目录: ${itemPath}`);
                    if (removeDirectory(itemPath)) {
                        deletedCount++;
                    }
                } else {
                    console.log(`保留有效目录: ${itemPath}`);
                }
            }
        }

        console.log(`\n处理完成: 共检查 ${totalDirs} 个目录, 删除了 ${deletedCount} 个无效目录`);
    } catch (error) {
        console.error(`处理目录时出错 ${parentDir}:`, error.message);
    }
}

/**
 * 清理 data 目录下所有子目录中的无效目录
 * @param {string} dataDir - data 目录路径
 */
function cleanAllDataDirs(dataDir = './data') {
    try {
        if (!fs.existsSync(dataDir)) {
            console.log(`data 目录不存在: ${dataDir}`);
            return;
        }

        const items = fs.readdirSync(dataDir);
        
        for (const item of items) {
            const itemPath = path.join(dataDir, item);
            const stat = fs.statSync(itemPath);

            // 只处理目录，跳过 .zip 文件等
            if (stat.isDirectory()) {
                console.log(`\n正在处理目录: ${itemPath}`);
                cleanEmptySubDirs(itemPath);
            }
        }
    } catch (error) {
        console.error(`处理 data 目录时出错:`, error.message);
    }
}

// 如果直接运行此脚本
if (require.main === module) {
    console.log('开始清理无效目录...\n');
    cleanAllDataDirs();
    console.log('\n清理完成!');
}

module.exports = {
    isBodyEmpty,
    removeDirectory,
    cleanEmptySubDirs,
    cleanAllDataDirs
};